﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Windows.Forms;

namespace Noris.Schedule.Support.Services
{
	// DEKLARACE interface a args PRO SLUŽBY TYPU "DEKLARACE GRAFU"
	#region INTERFACE IGraphDeclarator : předpis pro vlastností programu, který definuje sadu grafů pro zobrazení v scheduli.
	/// <summary>
	/// Interface, který předepisuje vlastnosti programu, který definuje sadu grafů pro zobrazení v scheduli.
	/// </summary>
	/// <remarks>
	/// Tento soubor obsahuje deklarace grafů pro plánovací tabuli výroby.
	/// Deklarantů může být více, typicky je jeden deklarant za jednu skupinu grafů, s jedním datovým zdrojem (který si sám vytvoří).
	/// Deklarant je zodpovědný za to, že deklarované grafy a jejich datový zdroj budou konzistentní.
	/// Deklarant může vytvořit vlastní datový zdroj, 
	///  anebo může najít (pomocí metod v argumentu GraphDeclareArgs args.GetExternalDataSource()) jiný existující datový zdroj.
	///  (Anebo ještě lépe může vytvořit svůj datový zdroj, který generuje svoje data, 
	///   ale přitom se odkazuje na jiný datový zdroj, s nímž kooperuje, a tím přidává další možnosti = grafy a funkce).
	/// Deklaraci vyvolává interní logika plánovací tabule, která najde všechny deklaranty 
	///  - a to podle přítomnosti interface IGraphDeclarator.
	/// Prohledává všechny knihovny (DLL) v aktuálním adresáři plánovací tabule, jejichž jména souborů odpovídají konvenci "lcs.scheduler.*.*".
	/// </remarks>
	public interface IGraphDeclarator : IPlugin
	{
		/// <summary>
		/// V této metodě konkrétní služba deklaruje svoje grafy, které chce zobrazovat, včetně jejich parametrů.
		/// </summary>
		/// <param name="args"></param>
		void GraphDeclare(GraphDeclareArgs args);
	}
	#endregion
	#region CLASS GraphDeclareArgs : ARGUMENTY PRO METODU DEKLARACE GRAFŮ
	/// <summary>
	/// Argument hlavní metody deklarace grafu.
	/// Do tohoto argumentu se v metodě GraphDeclare() vepisují deklarace grafů (do GraphDeclarationList),
	/// a celková priorita této deklarace (do Priority).
	/// </summary>
	public class GraphDeclareArgs
	{
		#region KONSTRUKCE
		/// <summary>
		/// Konstruktor pro argumenty do deklarátoru.
		/// Argument obsahuje odkaz na metody GetExternalDataSource a TryGetExternalDataSource, zde se předávají delegáty.
		/// </summary>
		/// <param name="getDs">Delegát na metodu GetExternalDataSource()</param>
		/// <param name="tryGetDs">Delegát na metodu TryGetExternalDataSource()</param>
		internal GraphDeclareArgs(FindDataSource getDs, FindDataSource tryGetDs)
		{
			this._GraphDeclarationList = new List<GraphDeclarationCls>();
			this.Priority = 100F;
			this._GetExternalDataSource = getDs;
			this._TryGetExternalDataSource = tryGetDs;
		}
		private List<GraphDeclarationCls> _GraphDeclarationList;
		private FindDataSource _GetExternalDataSource;
		private FindDataSource _TryGetExternalDataSource;
		#endregion
		#region PROPERTY
		/// <summary>
		/// Soupis deklarací grafů, které daná služba definuje a chce zobrazovat.
		/// Služba nechť deklaruje tolik grafů a v takovém pořadí, které chce zobrazit.
		/// Systém se o to pokusí.
		/// Každý graf může mít svůj datový zdroj, anebo mohou mít společný objekt datového zdroje.
		/// Není ale možno, aby grafy z různých deklarací sdílely jeden datový zdroj.
		/// </summary>
		public List<GraphDeclarationCls> GraphDeclarationList { get { return this._GraphDeclarationList; } }
		/// <summary>
		/// Priorita deklarce grafů.
		/// Deklarace pocházející z různých zdrojů se touto prioritou setřídí a v tom pořadí se vytvoří jejich prezentace.
		/// Priorita má význam jako u dalších služeb: 0=zakázáno (deklarace se ignoruje, umožníme tak deklarantu aby se disabloval),
		/// vyšší hodnoty jsou prioritnější = budou v TABu zařazeny nahoru / doleva. Nižší hodnoty jsou "pozdější".
		/// </summary>
		public float Priority { get; set; }
		#endregion
		#region ODKAZY NA METODY PRO HLEDÁNÍ EXTERNÍHO DATOVÉHO ZDROJE
		/// <summary>
		/// Metoda najde a vrátí datový zdroj daného typu.
		/// Pokud jej nenajde, přeruší se výkon metody IGraphDeclarator.GraphDeclare().
		/// Metoda bude spuštěna opakovaně pozdějí, až bude vytvořený externí datový zdroj.
		/// </summary>
		public FindDataSource GetExternalDataSource { get { return this._GetExternalDataSource; } }
		/// <summary>
		/// Metoda najde a vrátí datový zdroj daného typu.
		/// Pokud jej nenajde, vrátí null - výkon metody IGraphDeclarator.GraphDeclare() tedy nebude přerušen.
		/// V tom případě si musí metoda pomoci sama i bez externího datového zdroje. Typicky si jej vytvoří sama.
		/// Tuto metodu TryGetExternalDataSource() tedy volá takový deklarátor, který se buď napojuje na již existující zdroj, 
		/// anebo si tento zdroj může vytvořit sám.
		/// Pokud deklarátor chce přerušit svůj běh tak jako k tomu dojde v metodě GetExternalDataSource(),
		/// pak má vyhodít výjimku IdsException.
		/// </summary>
		public FindDataSource TryGetExternalDataSource { get { return this._TryGetExternalDataSource; } }
		#endregion
	}
	/// <summary>
	/// Delegát na metodu, která vyhledá datový zdroj podle jeho typu
	/// </summary>
	/// <param name="dataSourceType"></param>
	/// <returns></returns>
	public delegate IDataSource FindDataSource(Type dataSourceType);
	#region EXCEPTION IdsException : Neexistující datový zdroj
	/// <summary>
	/// Neexistující datový zdroj
	/// </summary>
	public class IdsException : HegException
	{
		/// <summary>Název typu chyby</summary>
		public new string ErrTyp = "Dosud neexistuje datový zdroj";
		/// <summary>Implicitní konstruktor</summary>
		public IdsException()
		{ }
		/// <summary>Explicitní konstruktor</summary>
		/// <param name="message">Zpráva o chybě</param>
		public IdsException(string message)
			: base(message)
		{ }
		/// <summary>Explicitní konstruktor</summary>
		/// <param name="message">Zpráva o chybě</param>
		/// <param name="inner">Vnitřní výjimka</param>
		public IdsException(string message, Exception inner)
			: base(message, inner)
		{ }
	}
	#endregion
	#endregion
	#region CLASS GraphDeclarationCls : DEKLARACE JEDNOHO GRAFU = GRAFICKÁ JEDNOTKA
	/// <summary>
	/// Data, pomocí kterých je deklarován jeden graf
	/// </summary>
	public class GraphDeclarationCls
	{
		/// <summary>
		/// Konstruktor pro graf, který načítá celý seznam jedné třídy (zadává se číslo třídy).
		/// </summary>
		/// <param name="defaultGraphMode">Výchozí režim grafu</param>
		/// <param name="rowClassNumber">Výchozí číslo třídy. Pokud bude kladné, předá se do datového zdroje pro načtení všech řádků této třídy.</param>
		/// <param name="dataSource">Objekt datového zdroje. Pokud má více grafů sdílet jeden datový zdroj, 
		/// musí se definice grafů zadat najednou a s jedním objektem datového zdroje.</param>
		/// <param name="graphCaption">Popisek grafu. 
		/// U grafu na celou stránku, anebo v horní polovině stránky jde o text na záložce, 
		/// u grafu v dolní polovině je text uveden na dělítku (Splitter).</param>
		/// <param name="graphPosition">Požadovaná pozice grafu.</param>
		public GraphDeclarationCls(RowGraphMode defaultGraphMode, int rowClassNumber, IDataSource dataSource, object tag, string graphCaption, GraphPositionType graphPosition)
		{
            this.RowGraphDeclaration = new DataRowGraphDeclaration(defaultGraphMode);
            this.DefaultGraphMode = defaultGraphMode;
			this.RowClassNumber = rowClassNumber;
			this.RowList = null;
			this.DataSource = dataSource;
			this.Tag = tag;
			this.GraphCaption = graphCaption;
			this.GraphPosition = graphPosition;
			this._FillDefaults();
		}
		/// <summary>
		/// Konstruktor pro graf, který načítá vybrané záznamy, možno i z různých tříd.
		/// </summary>
		/// <param name="defaultGraphMode">Výchozí režim grafu</param>
		/// <param name="rowList">Seznam čísel záznamů (číslo třídy a číslo záznamu) pro výchozí položky do zobrazení grafu</param>
		/// <param name="dataSource">Objekt datového zdroje. Pokud má více grafů sdílet jeden datový zdroj, 
		/// musí se definice grafů zadat najednou a s jedním objektem datového zdroje.</param>
		/// <param name="graphCaption">Popisek grafu. 
		/// U grafu na celou stránku, anebo v horní polovině stránky jde o text na záložce, 
		/// u grafu v dolní polovině je text uveden na dělítku (Splitter).</param>
		/// <param name="graphPosition">Požadovaná pozice grafu.</param>
		public GraphDeclarationCls(RowGraphMode defaultGraphMode, List<GID> rowList, IDataSource dataSource, object tag, string graphCaption, GraphPositionType graphPosition)
		{
			this.DefaultGraphMode = defaultGraphMode;
			this.RowClassNumber = 0;
			this.RowList = rowList;
			this.DataSource = dataSource;
			this.Tag = tag;
			this.GraphCaption = graphCaption;
			this.GraphPosition = graphPosition;
			this._FillDefaults();
		}
		/// <summary>
		/// Vizualizace
		/// </summary>
		/// <returns></returns>
		public override string ToString()
		{
			string result = "{" + this.GraphCaption + " (" + this.DefaultGraphMode + ", ";
			if (this.RowClassNumber != 0)
				result += "for Class=" + this.RowClassNumber;
			else if (this.RowList != null)
				result += "for GID List, Count=" + this.RowList.Count;
			else
				result += "undefined data)";
			result += "}";
			return result;
		}
		/// <summary>
		/// Výchozí režim grafu
		/// </summary>
		public RowGraphMode DefaultGraphMode { get; set; }
		/// <summary>
		/// Výchozí číslo třídy. Pokud bude kladné, předá se do datového zdroje pro načtení všech řádků této třídy.
		/// </summary>
		public int RowClassNumber { get; set; }
		/// <summary>
		/// Seznam čísel záznamů (číslo třídy a číslo záznamu) pro výchozí položky do zobrazení grafu
		/// </summary>
		public List<GID> RowList { get; set; }
		/// <summary>
		/// Objekt datového zdroje. Pokud má více grafů sdílet jeden datový zdroj, 
		/// musí se definice grafů zadat najednou a s jedním objektem datového zdroje.
		/// </summary>
		public IDataSource DataSource { get; set; }
		/// <summary>
		/// Libovolná informace předávaná spolu s grafem do požadavků do datového zdroje v requestu (v request.Tag)
		/// </summary>
		public object Tag { get; set; }
		/// <summary>
		/// Popisek grafu. 
		/// U grafu na celou stránku, anebo v horní polovině stránky jde o text na záložce, 
		/// u grafu v dolní polovině je text uveden na dělítku (Splitter).
		/// </summary>
		public string GraphCaption { get; set; }
		/// <summary>
		/// Požadovaná pozice grafu.
		/// </summary>
		public GraphPositionType GraphPosition { get; set; }
		/// <summary>
		/// Barva záložky / dělítka
		/// </summary>
		public Color TabColor { get; set; }
        /// <summary>
        /// Deklarace vlastností řádku.
        /// Zde nesmí být null, ani nesmí null obsahovat.
        /// Slouží jako implicitní hodnota pro ty řádky, které nemají vlastní deklaraci řádku (IDataRow.RowGraphDeclaration mají null, nebo v některé property null obsahují).
        /// </summary>
        public DataRowGraphDeclaration RowGraphDeclaration { get; set; }
        #region Skupina property provázaných s this.RowGraphDeclaration
        /// <summary>
        /// Barva pozadí řádku
        /// </summary>
        public Color RowColor { get { return this.RowGraphDeclaration.RowColor; } set { this.RowGraphDeclaration.RowColor = value; } }
		/// <summary>
		/// Nejvyšší výška řádku grafu, v pixelech.
		/// Rovnání do výšky se uplatňuje pouze u grafu typu RowGraphMode.TaskCapacityLink.
		/// Pokud by v grafu bylo více položek nad sebou, tak že by výška řádku překročila tuto hodnotu, 
		/// bude řádek "zhuštěný" tak, aby nepřekročil tuto výšku.
		/// Pokud bude uvedena hodnota 0, nebude se výška řádku kontrolovat.
		/// Hodnoty menší a rovno 10 budou rovněž ignorovány, z praktických důvodů zobrazování.
		/// Implicitní hodnota je 48 pixelů, avšak pro graf typu RowGraphMode.TaskCapacityLink je to 250 pixelů.
		/// </summary>
        public int RowHeightTotalMaxPx { get { return this.RowGraphDeclaration.RowHeightTotalMaxPx; } set { this.RowGraphDeclaration.RowHeightTotalMaxPx = value; } }
        /// <summary>
        /// Nejmenší výška řádku, pod kterou neklesne ani když by neměl co zobrazit v případě TaskCapacityLink.
        /// </summary>
        public int RowHeightTotalMinPx { get { return this.RowGraphDeclaration.RowHeightTotalMinPx; } set { this.RowGraphDeclaration.RowHeightTotalMinPx = value; } }
		/// <summary>
		/// Typická výška jednoho řádku.
		/// U většiny typů grafu jde o výšku celého řádku.
		/// U grafu typu RowGraphMode.TaskCapacityLink jde o výšku vyhrazenou pro jeden stroj (výška řádku je daná počtem použitých strojů).
		/// Pokud v grafu RowGraphMode.TaskCapacityLink je řádek využívaný v podílech (UseRatio je menší než 1), 
		/// pak se pro takový řádek použije výška linky ne tato (RowHeightOneLine), ale RowHeightOneFragmentedLine.
		/// Implicitní hodnota je 24 pixelů, avšak pro graf typu RowGraphMode.TaskCapacityLink je to 9 pixelů.
		/// Platná hodnota je 7 až 100 pixelů. Jiné hodnoty budou zarovnány do těchto mezí.
		/// </summary>
        public int RowHeightLineSolidPx { get { return this.RowGraphDeclaration.RowHeightLineSolidPx; } set { this.RowGraphDeclaration.RowHeightLineSolidPx = value; } }
		/// <summary>
		/// Typická výška jednoho řádku, pokud jde o řádek typu RowGraphMode.TaskCapacityLink, 
		/// a na tomto řádku je detekováno podílové čerpání kapacity (UseRatio je menší než 1).
		/// Systém sám detekuje takové řádky, a vykresluje je v této výšce linky namísto výšky RowHeightOneLine.
		/// Jde opět o výšku pro jeden stroj. Pokud bude v rámci kapacitní jednotky použito více (N) strojů, bude výška řádku N× vyšší.
		/// Implicitní hodnota je 60 pixelů.
		/// Platná hodnota je 7 až 100 pixelů. Jiné hodnoty budou zarovnány do těchto mezí.
		/// </summary>
        public int RowHeightLineFragmentPx { get { return this.RowGraphDeclaration.RowHeightLineFragmentPx; } set { this.RowGraphDeclaration.RowHeightLineFragmentPx = value; } }
		/// <summary>
		/// Výška nejmenšího zlomku v grafu typu RowGraphMode.TaskCapacityLink, kdy jsou zobrazeny položky využívající podíl kapacity.
		/// Pokud například operace využije 1/10 kapacity (plochy) stroje, a výška linky (RowHeightOneFragmentedLine) bude 30 pixelů, 
		/// pak by výška využití této 1/10 kapacity byla 3 pixely. Což je téměř neviditelné.
		/// Proto je možno deklarovat výšku minimálního zlomku: pokud v takovém případě bude RowHeightMinFragment = 6,
		/// pak fragment využívající 1/10 kapacity bude vysoký 6 pixelů, a úměrně k tomu bude výška linky = 60 pixelů (namísto zadaných 30).
		/// Implicitní hodnota je 4 pixely.
		/// Platná hodnota je 2 až 25 pixelů. Jiné hodnoty budou zarovnány do těchto mezí.
		/// </summary>
        public int RowHeightMinFragmentPx { get { return this.RowGraphDeclaration.RowHeightMinFragmentPx; } set { this.RowGraphDeclaration.RowHeightMinFragmentPx = value; } }
		/// <summary> { get; }
		/// Přídavek k výšce neděleného řádku, vyjádřený relativně k hodnotě this.RowHeightOneLine (fyzická výška jedné linky).
		/// Přídavek je vykreslen nad horní linkou (strojem) jako prázdné místo.
		/// Implicitní hodnota je 0.00 (nic se nepřidává), avšak pro graf typu RowGraphMode.TaskCapacityLink je to 1.00
		/// </summary>
        public decimal RowHeightAddLineSolidRatio { get { return this.RowGraphDeclaration.RowHeightAddLineSolidRatio; } set { this.RowGraphDeclaration.RowHeightAddLineSolidRatio = value; } }
		/// <summary> { get; }
		/// Přídavek k výšce děleného řádku, vyjádřený relativně k hodnotě this.RowHeightOneLine (fyzická výška jedné linky).
		/// Přídavek je vykreslen nad horní linkou (strojem) jako prázdné místo.
		/// Implicitní hodnota je 0.00 (nic se nepřidává), avšak pro graf typu RowGraphMode.TaskCapacityLink je to 0.25
		/// </summary>
        public decimal RowHeightAddLineFragmentRatio { get { return this.RowGraphDeclaration.RowHeightAddLineFragmentRatio; } set { this.RowGraphDeclaration.RowHeightAddLineFragmentRatio = value; } }
        #endregion
        /// <summary>
		/// Vrstva, kam se vykreslí linky časové osy v tomto grafu.
		/// Default = SubElements.
		/// </summary>
		public GraphLinePosition TimeTickLayer { get; set; }
		/// <summary>
		/// Vrstva, kam se vykreslí linky jednotek v grafu kapacitních jednotek, kde jsou kresleny fragmenty (částečné = podílové využití kapacity).
		/// Default = SubElements.
		/// </summary>
		public GraphLinePosition FragmentLineLayer { get; set; }
		/// <summary>
		/// Kreslit síť vztahů kolem elementu, na který se kliknulo.
		/// Default = true.
		/// </summary>
		public bool DrawElementRelationsOnClick { get; set; }
		/// <summary>
		/// Kreslit síť vztahů kolem elementu, který se právě edituje.
		/// Default = true.
		/// </summary>
		public bool DrawElementRelationsInEditing { get; set; }
		/// <summary>
		/// Režim kreslení linků = vztahy mezi svázanými úkoly.
		/// Default = LinkElementDrawMode.HighlightActiveLink
		/// </summary>
		public LinkElementDrawMode DrawLinkMode { get; set; }
		/// <summary>
		/// Definice mezigrafové aktivity:
		/// Určení pozice sousedních grafů, do kterých se předává událost DataChanged na tomto grafu.
		/// Default = Anywhere.
		/// </summary>
		public TargetGraphCrossActivityMode TargetGraphActivityOnDataChanged { get; set; }
		/// <summary>
		/// Definice mezigrafové aktivity:
		/// Určení pozice sousedních grafů, do kterých se předává událost RowEnter na tomto grafu.
		/// Default = None.
		/// </summary>
		public TargetGraphCrossActivityMode TargetGraphActivityOnRowEnter { get; set; }
		/// <summary>
		/// Definice mezigrafové aktivity:
		/// Určení pozice sousedních grafů, do kterých se předává událost Click na tomto grafu.
		/// Default = Anywhere.
		/// </summary>
		public TargetGraphCrossActivityMode TargetGraphActivityOnClick { get; set; }
		/// <summary>
		/// Definice mezigrafové aktivity:
		/// Určení pozice sousedních grafů, do kterých se předává událost DoubleClick na tomto grafu.
		/// Default = Anywhere.
		/// </summary>
		public TargetGraphCrossActivityMode TargetGraphActivityOnDoubleClick { get; set; }
		/// <summary>
		/// Definice mezigrafové aktivity:
		/// Určení reakce tohoto grafu na událost DataChanging v jiném grafu (aktivita v průběhu editace = při tažení elementu po grafu).
		/// Pro upřesnění: jiný graf právě edituje svoje data, a dosud nevyvolal request DataSourceRequestType.EventAfterEdit do datového zdroje.
		/// Jen mění svoje data na vizuální vrstvě.
		/// Náš graf je v tuto chvíli pasivním příjemcem této editace, a jen má reagovat na editovaná data.
		/// Default = CurrentGraphCrossActivityMode.None
		/// Poznámka: target aktivita se neurčuje, je implicitní na hodnotě OnThisPage (tento event se zásadně předává jen do sousedního grafu na téže stránce).
		/// </summary>
		public CurrentGraphCrossActivityMode CurrentGraphActivityOnDataChanging { get; set; }
		/// <summary>
		/// Definice mezigrafové aktivity:
		/// Určení reakce tohoto grafu na událost DataChanged v jiném grafu.
		/// Pro upřesnění: jiný graf editoval svoje data, a na závěr zavolal svůj datový zdroj, jemuž předal request DataSourceRequestType.EventAfterEdit.
		/// Náš graf je v tuto chvíli pasivním příjemcem této editace, a jen má reagovat na editovaná data.
		/// Default = CurrentGraphCrossActivityMode.DefaultEdit
		/// </summary>
		public CurrentGraphCrossActivityMode CurrentGraphActivityOnDataChanged { get; set; }
		/// <summary>
		/// Definice mezigrafové aktivity:
		/// Určení reakce tohoto grafu na událost RowEnter na řádku v jiném grafu.
		/// Default = None.
		/// </summary>
		public CurrentGraphCrossActivityMode CurrentGraphActivityOnRowEnter { get; set; }
		/// <summary>
		/// Definice mezigrafové aktivity:
		/// Určení reakce tohoto grafu na událost Click na elementu v jiném grafu.
		/// Default = CurrentGraphCrossActivityMode.DefaultClick
		/// </summary>
		public CurrentGraphCrossActivityMode CurrentGraphActivityOnClick { get; set; }
		/// <summary>
		/// Definice mezigrafové aktivity:
		/// Určení reakce tohoto grafu na událost DoubleClick na elementu v jiném grafu.
		/// Default = CurrentGraphCrossActivityMode.DefaultClick
		/// </summary>
		public CurrentGraphCrossActivityMode CurrentGraphActivityOnDoubleClick { get; set; }
		/// <summary>
		/// Definice mezigrafové aktivity:
		/// Má se volat datový zdroj při aktivaci stránky s tímto grafem?
		/// Default = false
		/// </summary>
		public bool CurrentGraphCallDataSourceOnActivate { get; set; }
		/// <summary>
		/// Definice mezigrafové aktivity:
		/// Má se volat datový zdroj při deaktivaci stránky s tímto grafem?
		/// Default = false
		/// </summary>
		public bool CurrentGraphCallDataSourceOnDeactivate { get; set; }
		/// <summary>
		/// Naplní defaultní hodnoty
		/// </summary>
		private void _FillDefaults()
		{
			this.TabColor = Color.Empty;
            this.RowColor = Color.Empty;
			this.TimeTickLayer = GraphLinePosition.SubElements;
			this.FragmentLineLayer = GraphLinePosition.SubElements;
			this.DrawElementRelationsOnClick = true;
			this.DrawElementRelationsInEditing = true;
			this.DrawLinkMode = LinkElementDrawMode.HighlightActiveLink;
			this.TargetGraphActivityOnDataChanged = TargetGraphCrossActivityMode.Anywhere;
			this.TargetGraphActivityOnRowEnter = TargetGraphCrossActivityMode.None;
			this.TargetGraphActivityOnClick = TargetGraphCrossActivityMode.Anywhere;
			this.TargetGraphActivityOnDoubleClick = TargetGraphCrossActivityMode.Anywhere;
			this.CurrentGraphActivityOnDataChanging = CurrentGraphCrossActivityMode.None;
			this.CurrentGraphActivityOnDataChanged = CurrentGraphCrossActivityMode.DefaultEdit;
			this.CurrentGraphActivityOnRowEnter = CurrentGraphCrossActivityMode.None;
			this.CurrentGraphActivityOnClick = CurrentGraphCrossActivityMode.DefaultClick;
			this.CurrentGraphActivityOnDoubleClick = CurrentGraphCrossActivityMode.DefaultClick;
			this.CurrentGraphCallDataSourceOnActivate = false;
			this.CurrentGraphCallDataSourceOnDeactivate = false;
		}
	}
	/// <summary>
	/// Umístění grafu
	/// </summary>
	public enum GraphPositionType
	{
		/// <summary>
		/// Graf je na celou stránku
		/// </summary>
		FullPage = 1,
		/// <summary>
		/// Graf by rád byl na horní polovině stránky
		/// </summary>
		TopPart,
		/// <summary>
		/// Graf by rád byl na dolní polovině stránky
		/// </summary>
		BottomPart
	}
	/// <summary>
	/// Pozice linek v grafu vzhledem ke grafickým elementům
	/// </summary>
	public enum GraphLinePosition
	{
		/// <summary>
		/// Linky budou vespodu = pod všemi elementy, tj. i pod elementem označujícím pracovní dobu
		/// </summary>
		AtBottom = 1,
		/// <summary>
		/// Linky budou pod datovými elementy, ale nad elementem označujícím pracovní dobu
		/// </summary>
		SubElements,
		/// <summary>
		/// Linky budou úplně navrchu
		/// </summary>
		OnTop
	}
	/// <summary>
	/// Režim zobrazování linků mezi elementy (svázané úkoly)
	/// </summary>
	public enum LinkElementDrawMode
	{
		/// <summary>
		/// Nekreslit vůbec
		/// </summary>
		NoDraw = 1,
		/// <summary>
		/// Kreslit jen linky aktivních elementů (to jsou elementy selectované, aktivní a pod myší)
		/// </summary>
		OnlyActiveLink,
		/// <summary>
		/// Kreslit všechny linky, a všechny stejně výrazně (nerozlišovat linky aktivních / neaktivních elementů)
		/// </summary>
		AllLinkVisible,
		/// <summary>
		/// Kreslit všechny linky, a všechny stejně, nevýraznou barvou (nezvýrazňovat linky aktivních elementů)
		/// </summary>
		AllLinkGloomy,
		/// <summary>
		/// Kreslit všechny linky, a linky aktivních elementů kreslit výrazněji
		/// </summary>
		HighlightActiveLink
	}
	/// <summary>
	/// Řízení mezigrafové aktivity - výběr cílových grafů po aktivitě na tomto grafu.
	/// </summary>
	public enum TargetGraphCrossActivityMode
	{
		/// <summary>
		/// Žádná aktivita
		/// </summary>
		None = 0,
		/// <summary>
		/// Aktivita se týká pouze sousedního grafu na téže straně (horní / dolní polovina stránky), 
		/// netýká se grafů na jiných stránkách.
		/// </summary>
		OnThisPage,
		/// <summary>
		/// Aktivita se týká pouze vedlejších stránek,
		/// netýká se grafu na druhé polovině téže stránky.
		/// </summary>
		OnOtherPage,
		/// <summary>
		/// Aktivita se týká kterékoli stránky a grafu.
		/// </summary>
		Anywhere
	}
	/// <summary>
	/// Řízení mezigrafové aktivity - chování tohoto grafu v reakci na události sousedních grafů.
	/// Hodnoty lze bitově sčítat.
	/// </summary>
	[Flags]
	public enum CurrentGraphCrossActivityMode
	{
		/// <summary>
		/// Žádná aktivita, tento graf nepřijímá aktivitu z jiných grafů
		/// </summary>
		None = 0,
		/// <summary>
		/// Najít řádek v tomto grafu, který odpovídá řádku ve zdrojovém grafu (shodný klíč GID).
		/// Bude ignorováno, pokud bude nastavena volba FindByDataSource.
		/// </summary>
		FindEqualRow = 1,
		/// <summary>
		/// Najít element (a tím i jeho řádek) v tomto grafu, který odpovídá elementu ve zdrojovém grafu (shodný klíč GID)
		/// Bude ignorováno, pokud bude nastavena volba FindByDataSource.
		/// </summary>
		FindEqualElement = FindEqualRow << 1,
		/// <summary>
		/// Najít zdejší řádek / element za pomoci requestu typu DataSourceRequestType.FindInterGraphTargetData, 
		/// který se pošle do datového zdroje tohoto grafu. 
		/// Výsledkem tohoto requestu je určení odpovídajícího řádku/elementu.
		/// Pokud je nastavena tato hodnota (FindByDataSource), pak jsou ignorovány hodnoty FindEqualRow a FindEqualElement.
		/// </summary>
		FindByDataSource = FindEqualElement << 1,
		/// <summary>
		/// Žádná aktivita, pokud je tento graf neviditelný (tj. je na jiné stránce než je právě zobrazena).
		/// Tj. tento graf přijímá aktivitu jen od sousedního grafu (nahoře / dole).
		/// </summary>
		InactiveWhenInvisible = FindByDataSource << 1,
		/// <summary>
		/// K vyhledanému řádku najít jeho Top parent řádek.
		/// Pokud se najde řádek kdesi v hloubce stromu, pak se vyhledá jeho nejvyšší parent.
		/// Tato hodnota (SelectParentTopRow) má význam ve spojení s hodnotou ActivateFirstEqualRow, 
		/// kdy dojde k zobrazení nalezeného řádku.
		/// Rovněž je vhodné přidat hodnotu OpenTreeNodes.
		/// </summary>
		SelectParentTopRow = InactiveWhenInvisible << 1,
		/// <summary>
		/// Nalezené elementy označit (Selected)
		/// </summary>
		SelectElements = SelectParentTopRow << 1,
		/// <summary>
		/// Pro nalezené elementy vygenerovat a zobrazit síť vztahů
		/// </summary>
		ShowRelationNet = SelectElements << 1,
		/// <summary>
		/// Aktivovat první odpovídající řádek. 
		/// Tato volba je téměř povinností, jinak většina ostatních akcí nemá význam.
		/// </summary>
		ActivateFirstEqualRow = ShowRelationNet << 1,
		/// <summary>
		/// Aktivovat stránku tohoto grafu, pokud není viditelná.
		/// Tj. pokud proběhne akce na jiné stránce, po které tento graf najde svůj řádek, pak se přepne zobrazení na tuto stránku a graf.
		/// </summary>
		ActivateGraphPage = ActivateFirstEqualRow << 1,
		/// <summary>
		/// Zajistit přenačtení obsahu (elementů) nalezených řádků
		/// </summary>
		InvalidateRows = ActivateGraphPage << 1,
		/// <summary>
		/// Zajistit přenačtení obsahu (elementů) i pro všechny parenty invalidovaných řádků.
		/// </summary>
		InvalidateAllParents = InvalidateRows << 1,
		/// <summary>
		/// Zajistit nové načtení všech řádků
		/// </summary>
		ReloadAllRows = InvalidateAllParents << 1,
		/// <summary>
		/// Otevřít položky stromu, které vedou k nalezenému řádku (pokud by byly zavřené).
		/// </summary>
		OpenActiveTreeNodes = ReloadAllRows << 1,
		/// <summary>
		/// Zavřít položky stromu, které neobsahují nalezený řádek. 
		/// Tato volba je platná pouze při současném zadání SelectParentTopRow a OpenActiveTreeNodes, jinak se neuplatní.
		/// Slovy: zavírání neaktivních top nodů je povoleno jen tehdy, když se pro aktivní nody mají vyhledávat jejich top parenty a otevírat.
		/// Tato volba (CloseInactiveTreeNodes) není implicitně nastavena.
		/// </summary>
		CloseInactiveTreeNodes = OpenActiveTreeNodes << 1,
		/// <summary>
		/// Pokud tento graf úspěšně najde svůj řádek/element, pak se tato událost už nebude předávat do dalších (následujících) grafů.
		/// </summary>
		StopProcess = CloseInactiveTreeNodes << 1,
		/// <summary>
		/// Defaultní hodnota 
		/// (FindEqualRow | SelectParentTopRow | OpenActiveTreeNodes | ActivateFirstEqualRow | ActivateGraphPage | StopProcess)
		/// </summary>
		DefaultClick = CurrentGraphCrossActivityMode.FindEqualRow |
				       CurrentGraphCrossActivityMode.SelectParentTopRow |
					   CurrentGraphCrossActivityMode.OpenActiveTreeNodes |
					   CurrentGraphCrossActivityMode.ActivateFirstEqualRow |
					   CurrentGraphCrossActivityMode.ActivateGraphPage |
					   CurrentGraphCrossActivityMode.StopProcess,
		/// <summary>
		/// Default pro editaci: najít shodné řádky (podle GIDu) a invalidovat je (FindEqualRow | InvalidateRows | InvalidateAllParents)
		/// </summary>
		DefaultEdit =  CurrentGraphCrossActivityMode.FindEqualRow |
					   CurrentGraphCrossActivityMode.InvalidateRows |
					   CurrentGraphCrossActivityMode.InvalidateAllParents
	}
	/// <summary>
	/// Druhy editace elementů v editoru
	/// </summary>
	[Flags]
	public enum GridEditingChangeMode
	{
		/// <summary>
		/// 0x00 : Zatím žádná změna neproběhla
		/// </summary>
		None = 0x00,
		/// <summary>
		/// 0x02 : Posun elementu na jiný čas
		/// </summary>
		MoveToTime = 0x02,
		/// <summary>
		/// 0x10 : Posun elementu na jiný řádek
		/// </summary>
		MoveToRow = 0x10,
		/// <summary>
		/// 0x12 : Posun elementu na jiný řádek a čas
		/// </summary>
		MoveToRowTime = 0x12,
		/// <summary>
		/// 0x01 : Změna šířky - posouvám počátek časového intervalu
		/// </summary>
		ResizeBegin = 0x01,
		/// <summary>
		/// 0x04 : Změna šířky - posouvám konec časového intervalu
		/// </summary>
		ResizeEnd = 0x04,
		/// <summary>
		/// 0x1000 : Invalidace řádků po dokončení editace
		/// </summary>
		InvalidateRows = 0x1000,
		/// <summary>
		/// Tento graf byl právě nyní aktivován (zobrazen)
		/// </summary>
		GraphActivated = 0x4000,
		/// <summary>
		/// Tento graf byl právě nyní deaktivován (zhasnut)
		/// </summary>
		GraphDeactivated = 0x8000
	}
	/// <summary>
	/// Druh události na grafu, s ním pracují metody grafu při specifikaci eventů
	/// </summary>
	public enum GraphEventType
	{
		/// <summary>Žádná událost</summary>
		None = 1,
		/// <summary>Myš se pohnula přes element</summary>
		MouseOver,
		/// <summary>Myš kliknula na element</summary>
		MouseClick,
		/// <summary>Myš doublekliknula na element</summary>
		MouseDoubleClick,
		/// <summary>Aktivovali jsme řádek, který dosud nebyl aktivní</summary>
		RowEnter,
		/// <summary>Probíhá změna dat (ještě stále se edituje)</summary>
		DataChanging,
		/// <summary>Proběhla a skončila změna dat</summary>
		DataChanged,
        /// <summary>Proběhla a skončila funkce, která měnila data</summary>
        FunctionChanged,
        /// <summary>Probíhá přenačtení všech dat grafu</summary>
        ReloadAllRows,
        /// <summary>Probíhá přepínání aktivní stránky, tento event se rozdělí na eventy PageDeactivated a PageActivated.</summary>
		PageSwitch,
		/// <summary>Aktivovali jsme tu záložku, na které je daný graf. Graf se stal viditelným.</summary>
		PageActivated,
		/// <summary>Aktivovali jsme jinou záložku, než na které je daný graf. Graf se stal neviditelným.</summary>
		PageDeactivated
	}
	#endregion
}
